home *** CD-ROM | disk | FTP | other *** search
/ The Arsenal Files 8 / The Arsenal Files Collection #8 (Arsenal Computer) (1996).ISO / g_duke / mapprt.zip / GRP.C < prev    next >
C/C++ Source or Header  |  1996-06-16  |  4KB  |  200 lines
  1. /*
  2.  
  3.     GRP.C
  4.  
  5.    Oliver Kraus
  6.    kraus@lrs.e-technik.uni-erlangen.de
  7.  
  8. */
  9.  
  10.  
  11. #include <stdlib.h>
  12. #include <stdio.h>
  13. #include <string.h>
  14. #include "grp.h"
  15.  
  16. int map_name_compare(char *n1, char *n2);
  17.  
  18.  
  19. /* global vars */
  20.  
  21. char *grp_id_str = "KenSilverman";
  22. #define GRP_ID_SIZE 12
  23.  
  24. grp_type qsort_grp;
  25.  
  26. int grp_dir_cmp( void *elem1, void *elem2 )
  27. {
  28.    int i1 = *(int *)(elem1);
  29.    int i2 = *(int *)(elem2);
  30.    return map_name_compare(qsort_grp->dir_list_ptr[i1].label,
  31.                            qsort_grp->dir_list_ptr[i2].label);
  32. }
  33.  
  34. int is_grp_file(char *name)
  35. {
  36.     FILE *fp;
  37.     char s[GRP_ID_SIZE];
  38.  
  39.     fp = fopen(name, "rb");
  40.     if ( fp == NULL )
  41.         return 0;
  42.  
  43.     if ( fread(s, GRP_ID_SIZE, 1, fp) != 1 )
  44.     {
  45.         fclose(fp);
  46.         return 0;
  47.     }
  48.     if ( strncmp(s, grp_id_str, GRP_ID_SIZE) != 0 )
  49.     {
  50.         fclose(fp);
  51.         return 0;
  52.     }
  53.     fclose(fp);
  54.     return 1;
  55. }
  56.  
  57. grp_type grp_Open(char *fname)
  58. {
  59.     grp_type grp;
  60.     grp = (grp_type)malloc(sizeof(grp_struct));
  61.     if ( grp != NULL )
  62.     {
  63.         grp->fname = (char *)malloc(strlen(fname)+1);
  64.         if ( grp->fname != NULL )
  65.         {
  66.             strcpy(grp->fname, fname);
  67.             grp->fp = fopen(fname, "rb");
  68.             if ( grp->fp != NULL )
  69.             {
  70.                 grp->is_id_ok = 0;
  71.                 grp->dir_list_len = 0L;
  72.                 grp->dir_list_ptr = NULL;
  73.             grp->dir_list_idx = NULL;
  74.                 grp->is_dir_ok = 0;
  75.                 return grp;
  76.             }
  77.             free(grp->fname);
  78.         }
  79.         free(grp);
  80.     }
  81.     return NULL;
  82. }
  83.  
  84. void grp_Close(grp_type grp)
  85. {
  86.     if ( grp != NULL )
  87.     {
  88.         if ( grp->dir_list_ptr != NULL )
  89.             free(grp->dir_list_ptr);
  90.       if ( grp->dir_list_idx != NULL )
  91.          free(grp->dir_list_idx);
  92.         fclose(grp->fp);
  93.         free(grp->fname);
  94.         free(grp);
  95.     }
  96. }
  97.  
  98. int grp_SeekFile(grp_type grp, long n)
  99. {
  100.    long pos, i;
  101.    if ( n >= grp->dir_list_len )
  102.       return 0;
  103.    pos = GRP_ID_SIZE;
  104.    pos += sizeof(long);
  105.    pos += (long)sizeof(grp_dir_struct)*grp->dir_list_len;
  106.    for( i = 0; i < n; i++ )
  107.    {
  108.       pos += grp->dir_list_ptr[i].size;
  109.    }
  110.    if ( fseek(grp->fp, pos, SEEK_SET) != 0 )
  111.    {
  112.       perror("seek within grp file");
  113.         return 0;
  114.    }
  115.    return 1;
  116. }
  117.  
  118. int grp_LoadId(grp_type grp)
  119. {
  120.     char *task = "grp file identifier";
  121.     char s[GRP_ID_SIZE];
  122.  
  123.     if ( fseek(grp->fp, 0L, SEEK_SET) != 0 )
  124.     {
  125.         perror(task);
  126.         return 0;
  127.     }
  128.     if ( fread(s, GRP_ID_SIZE, 1, grp->fp) != 1 )
  129.     {
  130.         perror(task);
  131.         return 0;
  132.     }
  133.     if ( strncmp(s, grp_id_str, GRP_ID_SIZE) != 0 )
  134.     {
  135.         fprintf(stderr, "%s: wrong identifier in file %s\n", task, grp->fname);
  136.         return 0;
  137.     }
  138.     grp->is_id_ok = 1;
  139.     return 1;
  140. }
  141.  
  142. int grp_LoadDirectory(grp_type grp)
  143. {
  144.     char *task = "grp directory";
  145.  
  146.     if ( grp->is_id_ok == 0 )
  147.         if ( grp_LoadId(grp) == 0 )
  148.             return 0;
  149.  
  150.     if ( fseek(grp->fp, GRP_ID_SIZE, SEEK_SET) != 0 )
  151.     {
  152.         perror(task);
  153.         return 0;
  154.     }
  155.  
  156.     if (fread(&(grp->dir_list_len), sizeof (long), 1, grp->fp) != 1)
  157.     {
  158.         perror(task);
  159.         return 0;
  160.     }
  161.  
  162.     if ( grp->dir_list_ptr != NULL )
  163.         free(grp->dir_list_ptr);
  164.     grp->dir_list_ptr =
  165.         (grp_dir_struct *)malloc(grp->dir_list_len*sizeof(grp_dir_struct));
  166.     if ( grp->dir_list_ptr == NULL )
  167.     {
  168.         fprintf(stderr, "%s: out of memory for directory of %s\n", task, grp->fname);
  169.         return 0;
  170.    }
  171.    grp->dir_list_idx =
  172.       (long *)malloc(grp->dir_list_len*sizeof(long));
  173.    if ( grp->dir_list_idx == NULL )
  174.     {
  175.       fprintf(stderr, "%s: out of memory for directory-index of %s\n", task, grp->fname);
  176.         return 0;
  177.    }
  178.  
  179.     {
  180.         long i;
  181.         for ( i = 0; i < grp->dir_list_len; i++ )
  182.       {
  183.          grp->dir_list_idx[i] = i;
  184.             if (fread(grp->dir_list_ptr+i, sizeof(grp_dir_struct), 1, grp->fp) != 1)
  185.             {
  186.                 perror(task);
  187.                 return 0;
  188.             }
  189.         }
  190.    }
  191.  
  192.    qsort_grp = grp;
  193.    qsort( grp->dir_list_idx, grp->dir_list_len, sizeof(long),
  194.             grp_dir_cmp);
  195.  
  196.     grp->is_dir_ok = 1;
  197.  
  198.     return 1;
  199. }
  200.